let tree = [
    {
        id: 1,
        title: '主页',
        children: [
            {
                id: 3,
                title: '欢迎',
                pid: 1,
                children: [
                    {
                        id: 10,
                        title: '日志',
                        pid: 3
                    }
                ]
            },
            {
                id: 4,
                title: '学员管理',
                pid: 1
            }
        ]
    },
    {
        id: 2,
        title: '用户中心'
    }
]

let res = repeatTree(tree)
console.log(res)
//将数组扁平化
function repeatTree(data) {
    let arr = []
    function server(data) {
        data.forEach(element => {
            arr.push({
                id: element.id,
                title: element.title,
                pid: element.pid ?? ''
            })
            if (element.children) {
                server(element.children)
            }
        })
    }
    server(data)
    return arr
}
//将扁平化数组树形化 方法一  //说到底，是对指针的整理成嵌套
let res2 = converTreen(res)
console.log(res2)

function converTreen(data) {
    //基于引用数据类型的存储特性，子代填进父代和顶级父代直接进入tree同时进行
    let tree = []
    data.forEach((item) => {
        let parent = data.find(v => {
            return v.id === item.pid
        })
        if (parent) {
            // 有父节点，放入父节点
            //根据引用数据存储的特点，即使自己进入数组parent.children，
            // 其子节点依然可以通过扁平数组添加它自己的children
            if (!parent.children) {
                parent.children = []
            }
            parent.children.push(item)
        } else {
            // 无父节点，放入tree
            //根据引用数据存储的特点，即使放入tree，
            // 其子节点依然可以通过扁平数组添加它的children
            tree.push(item)
        }
    })
    return tree
}


// //------------------华丽的分割线--------------------

// let res3 = converTreen(res)
// console.log(res3)

// //将扁平化数组树形化 方法二
// function converTreen(data) {
//     //基于子代对象不断向父级对象合并，合并完成后，再进到tree
//     let tree = []
//     return server(data)

//     function server(data) {
//         let childrenArr = []
//         let parentArr = []
//         //最后一层子父节点分离
//         data.forEach((element) => {
//             let children = data.find((item) => {
//                 return item.pid === element.id
//             })
//             if (!children) {
//                 //没找到自己的子节点
//                 childrenArr.push(element)
//             } else {
//                 parentArr.push(element)
//             }
//         })
//         //判断分离结果是否存在子父层级
//         if (parentArr.length !== 0) {
//             //部分存在子父层级
//             childrenArr.forEach((element) => {
//                 let target = parentArr.find((item) => {
//                     return item.id === element.pid
//                 })
//                 if (target) {
//                     //向下存在层级
//                     if (!target.children) {
//                         target.children = []
//                     }
//                     target.children.push(element)
//                 } else {
//                     //向上不存在层级
//                     tree.push(element)
//                 }
//             })
//             // 一层父子节点对接结束，得到新数组parentArr和tree
//             //再对parentArr进行子父层级判断
//             server(parentArr)
//         } else {
//             // 所有都不存在子父层级
//             childrenArr.forEach((element) => tree.push(element))
//         }
//         return tree
//     }
// }